home *** CD-ROM | disk | FTP | other *** search
/ IRIX Development Foundation for IRIX 6.4 / SGI IRIX 6.4 Development Foundation.iso / docs6.4 / relnotes / c++_dev / ch1.z / ch1
Text File  |  1997-09-11  |  73KB  |  2,181 lines

  1.  
  2.  
  3.  
  4.                                      - 1 -
  5.  
  6.  
  7.  
  8.           7.2 C++ Release Notes
  9.  
  10.  
  11.  
  12.  
  13.  
  14.  
  15.  
  16.  
  17.  
  18.  
  19.  
  20.  
  21.  
  22.  
  23.  
  24.  
  25.  
  26.  
  27.  
  28.  
  29.  
  30.  
  31.  
  32.  
  33.  
  34.  
  35.  
  36.  
  37.  
  38.  
  39.  
  40.  
  41.  
  42.           DDDDooooccccuuuummmmeeeennnntttt NNNNuuuummmmbbbbeeeerrrr 000000007777....2222666600006666----000011110000
  43.  
  44.  
  45.  
  46.  
  47.  
  48.  
  49.  
  50.  
  51.  
  52.  
  53.  
  54.  
  55.  
  56.  
  57.  
  58.  
  59.  
  60.  
  61.  
  62.  
  63.  
  64.  
  65.  
  66.                                      - 2 -
  67.  
  68.  
  69.  
  70.           1.  _I_n_t_r_o_d_u_c_t_i_o_n
  71.  
  72.           The Silicon Graphics C++ Compiler is an environment for
  73.           compiling programs written in the C++ programming language.
  74.           This environment allows access to standard IRIX features and
  75.           to the Graphics Library.
  76.  
  77.           The MIPSpro 7.2  release of the compiler is a native C++
  78.           compiler based on a frontend from the Edison Design Group.
  79.  
  80.           The latest set of compilers, invoked when -n32, -64, -mips3
  81.           or -mips4 is specified on the command-line, is based on the
  82.           n32/64 ABI, introduced with the 6.2 compilers.
  83.  
  84.           For backwards compatibility, the older ucode-based compilers
  85.           are also bundled with this release; these can be invoked
  86.           with -32,  -mips1, or -mips2.
  87.  
  88.           Note that the n32/64 compilers have been available for over
  89.           a year and we strongly recommend that you use these. Note
  90.           also that these n32/64 compilers closely reflect the C++
  91.           draft in terms of the language accepted and also provide the
  92.           features and performance enhancements described in detail
  93.           subsequently in these release notes.  There will be no
  94.           further development work on the ucode-based compilers.
  95.  
  96.  
  97.           The n32 and 64-bit versions are based on release 2.34 of the
  98.           Edison frontend.
  99.  
  100.           The 32-bit version is based on release 2.29 of the Edison
  101.           frontend.
  102.  
  103.           The old frontend based on release 3.0.1 of the USL C++
  104.           Translator (_c_f_r_o_n_t), is also available by specifying the
  105.           options -_3_2 -_u_s_e__c_f_r_o_n_t. Note that the use of this option is
  106.           being deprecated and the _c_f_r_o_n_t compiler will no longer be
  107.           supported in future releases.
  108.  
  109.  
  110.           1.1  _I_n_s_t_a_l_l_a_t_i_o_n__I_n_f_o_r_m_a_t_i_o_n
  111.  
  112.           This section lists supplemental information to the _I_R_I_S
  113.           _S_o_f_t_w_a_r_e _I_n_s_t_a_l_l_a_t_i_o_n _G_u_i_d_e.  The information listed here is
  114.           product-specific; use it with the installation guide to
  115.           install this product.
  116.  
  117.           _N_O_T_E:  Under the 7.2 release, the C++ compiler front-ends
  118.           are packaged in their own subsystem on a separate CD. For
  119.           proper installation, you must install _c_o_m_p_i_l_e_r__d_e_v,
  120.           _c_o_m_p_i_l_e_r__e_o_e, _c++__e_o_e and _c++__d_e_v from the IRIX Development
  121.  
  122.  
  123.  
  124.  
  125.  
  126.  
  127.  
  128.  
  129.  
  130.  
  131.  
  132.                                      - 3 -
  133.  
  134.  
  135.  
  136.           Foundation CD, as well as _c++__f_e from the MIPSpro C++
  137.           Compiler CD.
  138.  
  139.           The runtime libraries (DSOs) in the compiler_eoe and c++_eoe
  140.           subsystems are identical to what was shipped on the
  141.           corresponding IRIX releases and are provided as a
  142.           convenience. However, the subsystems will appear as upgrades
  143.           under inst, because changes have been made to certain non-
  144.           runtime library files.
  145.  
  146.           If, however, you need the latest runtime library fixes you
  147.           must install the subsystems from patch 2016 on top of this
  148.           image.
  149.  
  150.  
  151.           _c++__f_e (On MIPSpro C++ CD) contains:
  152.  
  153.              +o _f_e_c_c, the 64-bit and n32 C++ compiler frontend.
  154.  
  155.              +o _e_d_g_c_p_f_e, the 32-bit C++ compiler frontend.
  156.  
  157.              +o _e_d_g_c_p_f_e._e_h, the 32-bit C++ compiler frontend with
  158.                support for exception handling.
  159.  
  160.              +o Online manual page for _C_C(1).
  161.  
  162.  
  163.           _c++__d_e_v (On IRIX Development Foundation) contains:
  164.  
  165.              +o _C_C, the C++ compiler driver (not to be confused with
  166.                _c_c).
  167.  
  168.              +o The utilities _e_d_g__p_r_e_l_i_n_k, _c++_p_a_t_c_h and _c++_f_i_l_t.
  169.  
  170.              +o For users wishing to use the old frontend, _c_f_r_o_n_t, a
  171.                language translator for C++-to-C translation, and the
  172.                utilities _m_a_r_k_c++, _p_t_c_o_m_p, and _p_t_l_i_n_k. (_N_O_T_E: tttthhhheeee
  173.                ccccffffrrrroooonnnntttt----bbbbaaaasssseeeedddd ccccoooommmmppppiiiillllaaaattttiiiioooonnnn ssssyyyysssstttteeeemmmm iiiissss oooobbbbssssoooolllleeeesssscccceeeennnntttt,,,, aaaannnndddd
  174.                wwwwiiiillllllll bbbbeeee rrrreeeemmmmoooovvvveeeedddd iiiinnnn aaaa ffffuuuuttttuuuurrrreeee rrrreeeelllleeeeaaaasssseeee).
  175.  
  176.              +o The libraries _l_i_b_c_o_m_p_l_e_x._a, and _l_i_b_m_a_n_g_l_e._a.
  177.  
  178.              +o Include files specific to C++.
  179.  
  180.              +o These release notes.
  181.  
  182.              +o _C++ _P_r_o_g_r_a_m_m_e_r'_s _G_u_i_d_e, which includes the hard-copy
  183.                _C_C(1) manual page.
  184.  
  185.  
  186.  
  187.  
  188.  
  189.  
  190.  
  191.  
  192.  
  193.  
  194.  
  195.  
  196.  
  197.  
  198.                                      - 4 -
  199.  
  200.  
  201.  
  202.           The 32-bit C++ libraries /_u_s_r/_l_i_b/_l_i_b_C._s_o and
  203.           /_u_s_r/_l_i_b/_l_i_b_C_s_u_p._s_o are installed in the subsystem
  204.           _c++__e_o_e._s_w._l_i_b.  This allows application libraries written
  205.           in C++ to be used on systems that do not have C++ installed.
  206.           Note that these libraries are dynamic shared objects and not
  207.           an archive.  There are also   non-shared archive form of the
  208.           libraries, /_u_s_r/_l_i_b/_n_o_n_s_h_a_r_e_d/_l_i_b_C._a, and
  209.           /_u_s_r/_l_i_b/_n_o_n_s_h_a_r_e_d/_l_i_b_C_s_u_p._a.
  210.  
  211.           Note: The 64-bit and n32 versions of these libraries are
  212.              available in /_u_s_r/_l_i_b_6_4/ and /_u_s_r/_l_i_b_3_2/ directories
  213.              respectively.
  214.  
  215.              Note:  Packaged with this software is a separate sheet
  216.                     that contains the Software License Agreement.
  217.                     This software is provided to you solely under the
  218.                     terms and conditions of the Software License
  219.                     Agreement.  Please take a few moments to review
  220.                     the Agreement.
  221.  
  222.  
  223.           1.2  _R_e_l_e_a_s_e__I_d_e_n_t_i_f_i_c_a_t_i_o_n__I_n_f_o_r_m_a_t_i_o_n_
  224.  
  225.           Following is the release identification information for the
  226.           7.2 C++ Compiler.
  227.  
  228.                                     C++ Compiler
  229.           SSSSooooffffttttwwwwaaaarrrreeee OOOOppppttttiiiioooonnnn PPPPrrrroooodddduuuucccctttt
  230.                                     7.2
  231.           VVVVeeeerrrrssssiiiioooonnnn
  232.                                     SC4-C++-7.2
  233.           PPPPrrrroooodddduuuucccctttt CCCCooooddddeeee
  234.                                     IRIX 6.2 (or higher)
  235.                                     IRIX Development
  236.                                     Foundation 1.0
  237.           SSSSooooffffttttwwwwaaaarrrreeee RRRReeeeqqqquuuuiiiirrrreeeemmmmeeeennnnttttssss
  238.  
  239.  
  240.  
  241.  
  242.  
  243.           1.3  _O_n_l_i_n_e__R_e_l_e_a_s_e__N_o_t_e_s
  244.  
  245.           After you install the online documentation for a product
  246.           (the _r_e_l_n_o_t_e_s subsystem), you can view the release notes on
  247.           your screen.
  248.  
  249.           If you have a graphics system, select ``Release Notes'' from
  250.           the Tools submenu of the Toolchest. This displays the
  251.           _g_r_e_l_n_o_t_e_s(1) graphical browser for the online release notes.
  252.           Refer to the _g_r_e_l_n_o_t_e_s(1) man page for information on
  253.           options to this command.
  254.  
  255.           If you do not have a graphics system, you can use the
  256.           _r_e_l_n_o_t_e_s command.  Refer to the _r_e_l_n_o_t_e_s(1) man page for
  257.           accessing the online release notes.
  258.  
  259.  
  260.  
  261.  
  262.  
  263.  
  264.  
  265.  
  266.  
  267.                                      - 5 -
  268.  
  269.  
  270.  
  271.           1.4  _P_r_o_d_u_c_t__S_u_p_p_o_r_t
  272.  
  273.           Silicon Graphics, Inc., provides a comprehensive product
  274.           support and maintenance program for its products.
  275.  
  276.           If you are in the U.S. or Canada and would like support for
  277.           your Silicon Graphics-supported products, contact the
  278.           Technical Assistance Center at 1-800-800-4SGI.
  279.  
  280.           If you are outside the U.S. or Canada, contact the Silicon
  281.           Graphics subsidiary or authorized distributor in your
  282.           country.
  283.  
  284.           1.5  _C_+_+__C_o_m_p_i_l_e_r__S_u_b_s_y_s_t_e_m_s
  285.  
  286.           Following is a description of the C++ Compiler subsystems:
  287.  
  288.           _c++__d_e_v._s_w._c++                The C++ driver and associated
  289.                                         tools
  290.  
  291.           _c++__d_e_v._s_w._l_i_b                C++ demangling and complex
  292.                                         32-bit libraries
  293.  
  294.           _c++__d_e_v._s_w._l_i_b_r_w              Rogue Wave (TM) Tools.h++ (TM)
  295.                                         32-bit library
  296.  
  297.           _c++__d_e_v._s_w._l_i_b_n_s              Non_shared C++ 32-bit runtime
  298.                                         library
  299.  
  300.           _c++__d_e_v._s_w_3_2._l_i_b              C++ N32 demangling and complex
  301.                                         libraries
  302.  
  303.           _c++__d_e_v._s_w_3_2._l_i_b_r_w            Rogue Wave (TM) Tools.h++ (TM)
  304.                                         N32-bit library
  305.  
  306.           _c++__d_e_v._s_w_6_4._l_i_b              C++ 64-bit demangling and
  307.                                         complex libraries
  308.  
  309.           _c++__d_e_v._s_w_6_4._l_i_b_r_w            Rogue Wave (TM) Tools.h++ (TM)
  310.                                         64-bit library
  311.  
  312.           _c++__d_e_v._h_d_r._l_i_b               Standard C++ header files
  313.  
  314.           _c++__d_e_v._h_d_r._l_i_b_r_w             Rogue Wave (TM) Tools.h++ (TM)
  315.                                         library header files
  316.  
  317.           _c++__d_e_v._m_a_n._c++               Man pages for C++ and the
  318.                                         standard C++ header files
  319.  
  320.           _c++__d_e_v._m_a_n._l_i_b_r_w             Man pages for the Rogue Wave
  321.                                         (TM) Tools.h++ (TM) library
  322.  
  323.  
  324.  
  325.  
  326.  
  327.  
  328.  
  329.  
  330.  
  331.  
  332.  
  333.                                      - 6 -
  334.  
  335.  
  336.  
  337.           _c++__d_e_v._m_a_n._r_e_l_n_o_t_e_s          These release notes
  338.  
  339.           _c++__d_e_v._b_o_o_k_s._c++__P_G          C++ Language System
  340.                                         Programmer's Guide
  341.  
  342.  
  343.           1.6  _L_i_c_e_n_s_i_n_g__I_n_f_o_r_m_a_t_i_o_n
  344.  
  345.  
  346.  
  347.           1.6.1  _I_n_t_r_o_d_u_c_t_i_o_n
  348.  
  349.  
  350.           Your copy of the MIPSpro C++ Compiler requires a software
  351.           license in order to operate.  This section defines some
  352.           important software licensing terms, describes the basic
  353.           procedure for obtaining, installing, and testing a software
  354.           license for MIPSpro C++ Compiler, and lists a web site,
  355.           addresses, and phone numbers that you can use to contact
  356.           Silicon Graphics License Administration.
  357.  
  358.           For more information about installing and troubleshooting
  359.           software licenses you can look in the CD liner notes or
  360.           visit the web page:
  361.           http://www.sgi.com/Support/Licensing/install_docs.html on
  362.           Silicon Graphics' licensing website:
  363.           http://www.sgi.com/Products/license.html
  364.  
  365.           For in depth detail on FLEXlm licensing, see the FLEXlm
  366.           User's Guide, which covers using and administering FLEXlm
  367.           software licenses. The FLEXlm User's Guide, is included in
  368.           the system software documentation; the online InSight
  369.           version is in the subsystem license_eoe.books.FlexLM_UG
  370.           which is on the IRIX Development Foundation CD.
  371.  
  372.           Your purchased software is delivered with a label that
  373.           includes a temporary license and an Entitlement ID.  The
  374.           temporary license allows you to use the software until you
  375.           obtain your permanent license. However, your entitlement ID
  376.           number makes it possible to obtain your permanent license
  377.           instantly through Silicon Graphics' licensing website or
  378.           email autobot. For WEB site and email address see
  379.           "Contacting Silicon Graphics License Administration" at the
  380.           end of this chapter of the release notes.
  381.  
  382.  
  383.  
  384.  
  385.  
  386.  
  387.  
  388.  
  389.  
  390.  
  391.  
  392.  
  393.  
  394.  
  395.  
  396.  
  397.  
  398.  
  399.                                      - 7 -
  400.  
  401.  
  402.  
  403.           1.6.2  _A__F_e_w__D_e_f_i_n_i_t_i_o_n_s
  404.  
  405.  
  406.           A software license is a collection of information that,
  407.           after installation, allows you to use a licensed software
  408.           product on one or more systems.
  409.  
  410.           The software license information includes the license type,
  411.           the license expiration date, a license password, a system ID
  412.           number (/etc/sysinfo -s), and additional information
  413.           concerning the license and licensed software.  Floating
  414.           licenses have the host name (/sbin/uname -n) as part of the
  415.           license.
  416.  
  417.           There are two types of software licenses, node-locked and
  418.           floating:
  419.  
  420.  
  421.           1.6.2.1  _n_o_d_e_-_l_o_c_k_e_d
  422.  
  423.  
  424.           A node-locked license is installed on a particular system
  425.           (node) and allows the licensed software to run on that
  426.           system.
  427.  
  428.           For this release there are four different types of
  429.           nodelocked licenses each corresponding to a different
  430.           product pricing tier.
  431.  
  432.              +o The first tier allows you to run MIPSpro C on a system
  433.                of two or less processors.  It contains "CPU 2" in its
  434.                VENDOR STRING field.
  435.  
  436.              +o The second tier allows you to run MIPSpro C on a system
  437.                of eight or less processors.  It contains "CPU 8" in
  438.                its VENDOR STRING field.
  439.  
  440.              +o The third tier allows you to run MIPSpro C on a system
  441.                of 32 or less processors.  It contains "CPU 32" in its
  442.                VENDOR STRING field.
  443.  
  444.              +o The fourth tier allows you to run MIPSpro C on a system
  445.                of any number of processors.  It does not contain a
  446.                VENDOR STRING field.
  447.  
  448.  
  449.  
  450.  
  451.  
  452.  
  453.  
  454.  
  455.  
  456.  
  457.  
  458.  
  459.  
  460.  
  461.  
  462.  
  463.  
  464.  
  465.                                      - 8 -
  466.  
  467.  
  468.  
  469.           1.6.2.2  _f_l_o_a_t_i_n_g
  470.  
  471.  
  472.           A floating license allows the licensed software to run on
  473.           one or more systems in the network simultaneously. The
  474.           number of systems (nodes) allowed is included in the
  475.           software license information.
  476.  
  477.           When an application requires a license from a license
  478.           server, the floating license points the client to the
  479.           license server (server name and license file path are
  480.           included with the license and copied on all client systems).
  481.           The FLEXlm license daemon, lmgrd, is responsible for
  482.           checking out/in licenses (tokens) to/from client systems. As
  483.           long as the number of licenses checked out to clients at a
  484.           given time is less than the encrypted maximum number of
  485.           concurrent users no user is denied access. Once the maximum
  486.           number is reached, the next request for a license will be
  487.           denied.
  488.  
  489.           Floating licenses have the advantage of cost, since a
  490.           license can be shared over many infrequent users, but they
  491.           are harder to install and administer. Floating license
  492.           check-out times can also vary depending on the load of the
  493.           network and the time needed to reach the license server.
  494.  
  495.  
  496.  
  497.           1.6.2.3  _E_n_t_i_t_l_e_m_e_n_t__I_D
  498.  
  499.  
  500.           The Entitlement ID is a 15 digit number (shipped with the
  501.           software) which allows your permanent license request to be
  502.           processed and approved in seconds.
  503.  
  504.  
  505.           1.6.3  _O_b_t_a_i_n_i_n_g__a_n_d__I_n_s_t_a_l_l_i_n_g__a__S_o_f_t_w_a_r_e__L_i_c_e_n_s_e
  506.  
  507.  
  508.           This section explains the procedure for obtaining and
  509.           installing a software license:
  510.  
  511.  
  512.           1.6.3.1  _M_a_k_e _c_e_r_t_a_i_n _y_o_u _h_a_v_e _y_o_u_r _s_o_f_t_w_a_r_e _l_i_c_e_n_s_e
  513.                    _i_n_f_o_r_m_a_t_i_o_n
  514.  
  515.  
  516.           Software license information is distributed in several ways:
  517.           by WEB page, email, FAX, postal mail, or on sheets of paper
  518.           included with the product.
  519.  
  520.  
  521.  
  522.  
  523.  
  524.  
  525.  
  526.  
  527.  
  528.  
  529.  
  530.  
  531.                                      - 9 -
  532.  
  533.  
  534.  
  535.           If you are updating to this release of MIPSpro C++ Compiler
  536.           from an older release you need to obtain and install a new
  537.           license.
  538.  
  539.           If you have received both a temporary license and a
  540.           permanent software license, install the permanent license;
  541.           do not install the temporary license.
  542.  
  543.  
  544.           1.6.3.2  _I_d_e_n_t_i_f_y _t_h_e _s_y_s_t_e_m _o_n _w_h_i_c_h _y_o_u _w_i_l_l _i_n_s_t_a_l_l _t_h_e
  545.                    _s_o_f_t_w_a_r_e _l_i_c_e_n_s_e.
  546.  
  547.  
  548.           Because software license information usually must be
  549.           installed on a particular system, follow these guidelines:
  550.  
  551.           If the System ID field says ``ANY,'' then you can install
  552.           the license on any system you choose.
  553.  
  554.           Install a license on the machine which has a system ID (
  555.           /etc/sysinfo -s ) which matches the system ID in the
  556.           license.
  557.  
  558.  
  559.           1.6.3.3  _I_n_s_t_a_l_l _t_h_e _s_o_f_t_w_a_r_e _l_i_c_e_n_s_e (_t_e_m_p_o_r_a_r_y _o_r
  560.                    _p_e_r_m_a_n_e_n_t).
  561.  
  562.  
  563.           Licenses typically come with complete license installation
  564.           instructions.  Follow these instructions to install the
  565.           license. For more detailed license installation and trouble
  566.           shooting information see the web page:
  567.           http://www.sgi.com/Support/Licensing/install_docs.html
  568.  
  569.           Check the ``license type'' listed in the software license
  570.           information to find out whether the license is a node-locked
  571.           license or a floating license.  The installation procedure
  572.           depends on the license type:
  573.  
  574.           You can install the license "manually" or use the
  575.           LicenseManager(1M) tool.  You can bring up LicenseManager by
  576.           choosing ``License Manager'' from the System toolchest.
  577.  
  578.           If the license is a floating license, you may need to
  579.           configure the system on which you plan to install the
  580.           license as a license server.
  581.  
  582.  
  583.  
  584.  
  585.  
  586.  
  587.  
  588.  
  589.  
  590.  
  591.  
  592.  
  593.  
  594.  
  595.  
  596.  
  597.                                      - 10 -
  598.  
  599.  
  600.  
  601.           1.6.3.4  _V_e_r_i_f_y _t_h_a_t _t_h_e _s_o_f_t_w_a_r_e _l_i_c_e_n_s_e _h_a_s _b_e_e_n
  602.                    _s_u_c_c_e_s_s_f_u_l_l_y _i_n_s_t_a_l_l_e_d.
  603.  
  604.  
  605.           To verify that the software license is working, try running
  606.           the MIPSpro C++ Compiler. The licensed program in this
  607.           product is: CC(1). The FEATURE NAME in the license of this
  608.           product appears as cpp.
  609.  
  610.           For this release, C++ compilations will not be terminated if
  611.           the license is absent or incorrectly installed.  However, a
  612.           warning  message similar to the following will be displayed:
  613.  
  614.  
  615.           %CC -c foo.cpp
  616.           Cannot find license file (-1,73:2) No such file or directory
  617.  
  618.            The MIPSpro C++ Compiler
  619.            (license FEATURE string = cpp)
  620.            requires a license password.
  621.  
  622.            For license installation and trouble shooting
  623.            information visit the web page:
  624.  
  625.                    http://www.sgi.com/Support/Licensing/install_docs.html
  626.  
  627.            To obtain a Permanent license (proof of purchase
  628.            required) or an Evaluation license please
  629.            visit our license request web page:
  630.  
  631.                    http://www.sgi.com/Products/license.html
  632.  
  633.                    or send a blank email message to:
  634.  
  635.                    license@sgi.com
  636.  
  637.            In North America, Silicon Graphics' customers may request
  638.            Permanent licenses by sending a facsimile to:
  639.  
  640.                    (650) 932-0537
  641.  
  642.                    or by calling our technical support hotline
  643.  
  644.                    1-800-800-4SGI
  645.  
  646.            If you are Outside of North America or you are not a Silicon
  647.            Graphics support customer then contact your local support provider.
  648.  
  649.  
  650.  
  651.  
  652.  
  653.  
  654.  
  655.  
  656.  
  657.  
  658.  
  659.  
  660.  
  661.  
  662.  
  663.                                      - 11 -
  664.  
  665.  
  666.  
  667.           1.6.4  _C_o_n_t_a_c_t_i_n_g__S_i_l_i_c_o_n__G_r_a_p_h_i_c_s__L_i_c_e_n_s_e__A_d_m_i_n_i_s_t_r_a_t_i_o_n
  668.  
  669.  
  670.           If you are connected to the internet then you can request a
  671.           permanent license from any country in the world using either
  672.           of the following methods:
  673.  
  674.  
  675.              * WEB: Go the the web site:
  676.                http://www.sgi.com/Products/license.html
  677.                Look under the "License Request" section.
  678.  
  679.              * email: Send a blank email message to
  680.                license@sgi.com
  681.                You will be sent back a blank email license
  682.                request template with full instructions.
  683.  
  684.  
  685.           If are not connected to the internet and need to obtain a
  686.           software license, fill out the Software License Registration
  687.           sheet that was included inside the CD liner notes with the
  688.           software (or the replica in the Network License System
  689.           Administration Guide). Send or FAX the filled out Software
  690.           License Registration sheet to Silicon Graphics License
  691.           Administration or your local service provider. After your
  692.           request is received by Silicon Graphics or your local
  693.           service provider, you should receive a software license
  694.           within two business days.
  695.  
  696.           In the United States and Canada, Silicon Graphics License
  697.           Administration provides software license information to
  698.           Silicon Graphics customers. You can contact Silicon Graphics
  699.           License Administration in these ways:
  700.  
  701.  
  702.              * FAX: (650) 932-0537
  703.              * Mail:
  704.  
  705.                Software Licensing M/S 134
  706.                Silicon Graphics, Inc.
  707.                P.O. Box 7311
  708.                Mountain View, CA 94039-9600
  709.  
  710.  
  711.           In an emergency, you can telephone Silicon Graphics at (800)
  712.           800-4744.  If you are not in the United States or Canada, or
  713.           if you purchased the system or software from a vendor other
  714.           than Silicon Graphics, please contact your local service
  715.           provider.
  716.  
  717.  
  718.  
  719.  
  720.  
  721.  
  722.  
  723.  
  724.  
  725.  
  726.  
  727.  
  728.  
  729.                                      - 12 -
  730.  
  731.  
  732.  
  733.           1.7  _I_n_s_t_a_l_l_a_t_i_o_n__M_e_t_h_o_d
  734.  
  735.           All of the subsystems for the C++ Compiler can be installed
  736.           using _i_n_s_t from IRIX.
  737.  
  738.           For the details of this procedure, consult the _1._0 _I_R_I_X
  739.           _D_e_v_e_l_o_p_m_e_n_t _F_o_u_n_d_a_t_i_o_n release notes.
  740.  
  741.  
  742.           1.8  _N_e_w__F_e_a_t_u_r_e_s
  743.  
  744.           1.8.1  _M_I_P_S_p_r_o__A_u_t_o__P_a_r_a_l_l_e_l_i_z_i_n_g__O_p_t_i_o_n
  745.  
  746.           The MIPSpro Auto Parallelizing Option is a new product which
  747.           provides support for automatic parallelization for the
  748.           MIPSpro 7.2 family of compilers.  Similar to Power C
  749.           Analyzer and Power Fortran Analyzer, Auto Parallelizing
  750.           Option will automatically try parallelize C, C++, Fortran77
  751.           and Fortran90 programs when -pfa or -pca is specified on he
  752.           compiler command-line.  One copy of Auto Parallelizing
  753.           Option works for all four languages.  It only supports the
  754.           64-bit (-64) and new high performance 32-bit (-n32) ABI's.
  755.           The old 32-bit ABI (-32) is not supported by this product.
  756.  
  757.  
  758.           1.8.2  _D_a_t_a__D_i_s_t_r_i_b_u_t_i_o_n__D_i_r_e_c_t_i_v_e_s
  759.  
  760.           The MIPSpro 7.2 compiler operating in the n32 and 64-bit
  761.           mode provides for data distribution pragmas such as
  762.           distribute, and distribute-reshape, which allow for explicit
  763.           data parallelism to be exploited in a multi-processing
  764.           environment. This is in addition to the multi-processing MP
  765.           pragmas for which support has been provided since 7.1. The
  766.           programmer's guide describes the data distribution pragmas
  767.           and their use on multiprocessing machines such as the Origin
  768.           series.
  769.  
  770.  
  771.           1.8.3  _N_e_w__P_a_r_a_l_l_e_l__P_r_a_g_m_a__O_p_t_i_o_n_s
  772.  
  773.           MIPSpro 7.2 now supports some new optional arguments to the
  774.           pfor parallel pragmas when -mp is specified on the compiler
  775.           command-line: onto, nest, local, lastlocal, affinity, and
  776.           reduction.  Also, the synchronize pragma can now be used
  777.           outside of parallel regions.  See he MIPSpro C and C++
  778.           Pragmas document for more information on these parallel
  779.           pragmas.
  780.  
  781.  
  782.  
  783.  
  784.  
  785.  
  786.  
  787.  
  788.  
  789.  
  790.  
  791.  
  792.  
  793.  
  794.  
  795.                                      - 13 -
  796.  
  797.  
  798.  
  799.           1.8.4  _N_e_w__S_y_m_b_o_l__S_t_o_r_a_g_e__D_i_r_e_c_t_i_v_e_s
  800.  
  801.           Two new directives have been added in MIPSpro 7.2 to control
  802.           the way symbols are stored: ALIGN_SYMBOL and FILL_SYMBOL.
  803.           The ALIGN_SYMBOL directive aligns the start of symbol at a
  804.           specified alignment boundary. The FILL_SYMBOL directive pads
  805.           symbol with additional storage so that the symbol is assured
  806.           not to overlap with any other data item within the storage
  807.           of the specified size. The additional padding required is
  808.           divided between each end of the specified variable.
  809.  
  810.  
  811.           1.8.5  _V_a_r_i_a_b_l_e__L_e_n_g_t_h__A_r_r_a_y_s
  812.  
  813.           MIPSpro 7.2 now supports variable length arrays. Array dummy
  814.           arguments and local arrays can now be declared as variable
  815.           length arrays rather than as pointers.  This allows the
  816.           compiler to make assumptions about aliasing and can allow
  817.           more optimizations to be applied to code containing
  818.           references to the array.  This is particularly beneficial
  819.           for parallelization.  The syntax for variable length arrays
  820.           is:
  821.  
  822.           int foo( int n, float a[n][n] ) {
  823.              float b[n];
  824.           }
  825.  
  826.           In the example above, dummy argument a and local variable b
  827.           are both variable length arrays.
  828.  
  829.           Variable length arrays are provided in C++ as an
  830.           experimental feature and may not work in the presence of C++
  831.           features such as templates and exceptions.
  832.  
  833.  
  834.           1.8.6  _F_r_e_q_u_e_n_c_y__h_i_n_t__p_r_a_g_m_a_s
  835.  
  836.           MIPSpro 7.2 now supports a new pragma "#pragma
  837.           mips_freqency_hint" that is used to tell the compiler that a
  838.           branch or function is rarely executed. The compiler uses
  839.           this information to make better optimization decisions. A
  840.           branch can be marked a infreqently taken in this fashion:
  841.  
  842.           if ( a < b ) {
  843.           #pragma mips_frequency_hint NEVER
  844.              printf("error condition0);
  845.           }
  846.  
  847.           While a function can be so marked this way:
  848.  
  849.  
  850.  
  851.  
  852.  
  853.  
  854.  
  855.  
  856.  
  857.  
  858.  
  859.  
  860.  
  861.                                      - 14 -
  862.  
  863.  
  864.  
  865.           void handle_error( int i );
  866.           #pragma mips_frequency_hint NEVER handle_error
  867.  
  868.           Frequency information about a function gets propogated to
  869.           all instances where the function is used.  So a branch that
  870.           contains a call to an infrequent function is considered
  871.           infrequently executed itself.
  872.  
  873.           1.8.7  _P_R_I_N_T_F_L_I_K_E__l_i_n_t__s_t_y_l_e__c_o_m_m_e_n_t
  874.  
  875.           This comment applies lint style check to the first (n-1)
  876.           arguments as usual. The nth argument is interpreted as a
  877.           printf format string that is used to check the remaining
  878.           arguments.
  879.  
  880.           1.8.8  _S_C_A_N_F_L_I_K_E__l_i_n_t__s_t_y_l_e__c_o_m_m_e_n_t
  881.  
  882.           This comment applies lint style check to the first (n-1)
  883.           arguments as usual. The nth argument is interpreted as a
  884.           scanf format string that is used to check the remaining
  885.           arguments.
  886.  
  887.           1.8.9  _-_a_r__f_l_a_g_.
  888.  
  889.           ar(1) should not be invoked to create an archive of c++
  890.           objects. Instead the -ar flag of CC(1) should be used to
  891.           create an archive. This flag will instantiate all the
  892.           necessary template entities before creating the archive. See
  893.           -ar option in CC(1) man page.
  894.  
  895.  
  896.           1.9  _N_e_w__B_o_o_k_s
  897.  
  898.           MIPSPro C and C++ Pragmas
  899.  
  900.  
  901.           1.10  _C_o_m_p_a_t_i_b_i_l_i_t_y__w_i_t_h__c_+_+__7_._1
  902.  
  903.           The 7.2   C++ compiler operating in 32-bit mode as well as
  904.           n32 and 64-bit mode is fully link-compatible with code
  905.           compiled with C++ 7.1 with the following exceptions (n32 and
  906.           64-bit mode only):
  907.  
  908.           1.10.1  _-_e_x_p_e_r_i_m_e_n_t_a_l__f_l_a_g__n_o__l_o_n_g_e_r__s_u_p_p_o_r_t_e_d
  909.  
  910.           The flag -experimental, which could be used with the 7.1
  911.           compiler to invoke an experimental version which supported
  912.           namespaces, is no longer supported, since the released
  913.           compiler now supports namespaces and other new features.
  914.  
  915.  
  916.  
  917.  
  918.  
  919.  
  920.  
  921.  
  922.  
  923.  
  924.  
  925.  
  926.  
  927.                                      - 15 -
  928.  
  929.  
  930.  
  931.           1.10.2  _R_u_n_t_i_m_e _c_h_a_n_g_e _i_n _s_e_m_a_n_t_i_c_s _o_f _c_o_p_y _a_s_s_i_g_n_m_e_n_t
  932.                   _o_p_e_r_a_t_o_r _c_a_l_l_s
  933.  
  934.           This is a change in runtime behavior! It only affects you if
  935.           you define an assignment operator in class B, but the type
  936.           of argument that this operator accepts is not of type B.
  937.  
  938.           struct A {};
  939.           struct B {
  940.               B();
  941.               B& operator= (const A&);
  942.               operator A& ()  const;
  943.           };
  944.  
  945.           main()
  946.           {
  947.              B b1, b2;
  948.              b1 = b2;
  949.              return 0;
  950.           }
  951.  
  952.           With the 7.1 compilers, the statement b1 = b2 generated a
  953.           call to the conversion operator function "operator A& ()
  954.           const" to convert a B object to an object of type A followed
  955.           by a call to operator function "B& operator= () const(A&)"
  956.           to copy the A object.
  957.  
  958.           This behavior was incorrect since the function  "B&
  959.           operator= (const A&)" is not a copy assignment operator. A
  960.           copy assignment operator can take exactly one parameter of
  961.           the form A, A&, const A&, volatile A&, or const volatile A&.
  962.  
  963.           With the 7.2 compilers, the frontend will implicitly
  964.           generate a copy assignment operator of the form
  965.           B::operator=(const B &) which will perform a bitwise copy.
  966.           This may result in completely different runtime behavior.
  967.           The compiler will warn in such cases with the following
  968.           message:
  969.  
  970.           "t.c";, line 12: warning(3149): class "B" has no copy assignment operator. A
  971.                   copy assignment operator of the form
  972.                   "B::operator=(const B &)" has been implicitly defined. The
  973.                   implicitly defined copy assignment operator will perform a bitwise
  974.                   copy. Previous compiler versions may have used assignment operator
  975.                   functions defined in this class with conversion operators as copy
  976.                   assignment operators. This change may lead to different runtime
  977.                   behavior. Define a copy assignment operator if necessary.
  978.  
  979.           The suggested approach to fix the problem is to define a
  980.           copy assigment operator that performs the copy. In the above
  981.           test case, one could add a member function in B:
  982.  
  983.  
  984.  
  985.  
  986.  
  987.  
  988.  
  989.  
  990.  
  991.  
  992.  
  993.                                      - 16 -
  994.  
  995.  
  996.  
  997.           B& operator= (const B& arg) {
  998.             *this = ( const A&) arg; // Convert the argument to a 'A' object and
  999.                                       // then call the operator= function.
  1000.           }
  1001.  
  1002.           1.10.3  _P_r_e_v_i_o_u_s_l_y__u_n_d_i_a_g_n_o_s_e_d__e_r_r_o_r__o_n__n_o_n_m_e_m_b_e_r__o_p_e_r_a_t_o_r_s
  1003.  
  1004.           Non-member operators have always required at least one class
  1005.           (or reference to class) parameter. Earlier compilers have
  1006.           occasionally failed to diagnose this problem, particularly
  1007.           when this happened in template functions. C++ 7.2 will
  1008.           always give you a compile time error for this.
  1009.  
  1010.           template <class T>
  1011.           class Ptr{
  1012.           };
  1013.  
  1014.           template <class T&>
  1015.           int operator!=(Ptr<T>* a, Ptr<T>* b); //Should be an error
  1016.  
  1017.           The fix is to remove any such functions; they could not
  1018.           possibly have been invoked in earlier compilers, so removing
  1019.           them cannot change program behavior.
  1020.  
  1021.           1.10.4  _A_m_b_i_g_u_i_t_y__w_i_t_h__c_o_n_d_i_t_i_o_n_a_l__o_p_e_r_a_t_o_r
  1022.  
  1023.           This issue pertains to ?: expressions where the left and
  1024.           right arms are of different types. For example:
  1025.  
  1026.           struct A {
  1027.              A();
  1028.              A(int);
  1029.              operator int();
  1030.           };
  1031.  
  1032.           void foo(int i,int j) {
  1033.              i ? A() : j; //AMBIGUOUS in 7.2 -n32
  1034.           }
  1035.  
  1036.           "foo.c", line 8: error(1324): more than one operator"?" matches these
  1037.                     operands:
  1038.                       built-in operator "expression ? class : class"
  1039.                       built-in operator "expression ? arithmetic : arithmetic"
  1040.                       operand types are: A : int
  1041.                       Recent changes to Ansi C++ draft standard may have
  1042.                       made this expression ambiguous. Please rewrite
  1043.                       the expression to remove the ambiguity. To get the old behavior
  1044.                       use the "-Wf,-old_conditional_operator_rules" flag.
  1045.                i ? A() : j; //AMBIGUOUS in 7.2 -n32
  1046.  
  1047.           In the example above, the compiler could determine the
  1048.  
  1049.  
  1050.  
  1051.  
  1052.  
  1053.  
  1054.  
  1055.  
  1056.  
  1057.  
  1058.  
  1059.                                      - 17 -
  1060.  
  1061.  
  1062.  
  1063.           return type of the ?: in two ways:
  1064.  
  1065.              +o Convert the A() to an int and make the result of int
  1066.                type
  1067.  
  1068.              +o Convert the int to an A, and make the result of type A
  1069.  
  1070.           It is therefore an ambiguous construct. It used to be that
  1071.           the compiler would always prefer converting the A() to an
  1072.           int, but the standard now makes this ambiguous. The
  1073.           suggested way of making this code work with all compilers is
  1074.           to use an explicit cast to make the result type unambiguous.
  1075.           In this case, what was probably intended was:
  1076.  
  1077.           i ? (int)A() : j;
  1078.  
  1079.           The other choice would be:
  1080.  
  1081.           i ? A() : (A)j
  1082.  
  1083.           If you cannot change your source code, use the
  1084.            "-Wf,-old_conditional_operator_rules" flag.
  1085.  
  1086.           1.10.5  _E_n_u_m_e_r_a_t_o_r_s__c_a_n_n_o_t__b_e__c_o_n_v_e_r_t_e_d__t_o__p_o_i_n_t_e_r_s
  1087.  
  1088.           An enum in C++ is not a numeric type, and there is no
  1089.           implicit conversion to a pointer.  The 7.1 compiler failed
  1090.           to diagnose this error.
  1091.  
  1092.           enum fruit {orange};
  1093.           void* p = orange; //This is an error
  1094.           "foo.c", line 2: error(1140): a value of type "fruit" cannot be used to
  1095.                     initialize an entity of type "void *"
  1096.             void* p = orange;
  1097.  
  1098.           The way to fix this is to explicitly cast the enum to an
  1099.           int.
  1100.  
  1101.           enum fruit {orange};
  1102.           void* p = (int)orange; //This is fine
  1103.  
  1104.           1.10.6  _N_e_w__k_e_y_w_o_r_d_s
  1105.  
  1106.           There are four new reserved words in C++ 7.2: "typename",
  1107.           "explicit", "namespace", and "mutable". All existing code
  1108.           should be modified so that it does not use these words as
  1109.           identifiers.  If for some reason you are unable to modify
  1110.           code that uses these reserved words (e.g. it's in a third
  1111.           party header), you can use any combination of the following
  1112.           options: -LANG:explicit=off, or -LANG:typename=off, or
  1113.           -LANG:namespace=off or -LANG:mutable=off Note that in a
  1114.  
  1115.  
  1116.  
  1117.  
  1118.  
  1119.  
  1120.  
  1121.  
  1122.  
  1123.  
  1124.  
  1125.                                      - 18 -
  1126.  
  1127.  
  1128.  
  1129.           future release "export" will also be made a keyword, so you
  1130.           should not be using this as an identifier.
  1131.  
  1132.  
  1133.  
  1134.           1.10.7  _S_t_a_n_d_a_r_d__p_l_a_c_e_m_e_n_t__n_e_w__c_a_n_n_o_t__b_e__p_r_e_e_m_p_t_e_d
  1135.  
  1136.           A placement version of operator new used to be defined as
  1137.           follows in new.h:
  1138.  
  1139.              void *operator new(size_t, void* p);
  1140.  
  1141.           The library used to provide the obvious implementation:
  1142.  
  1143.              void *operator new(size_t, void* p) {return p; }
  1144.  
  1145.           The C++ standard now states that the standard version of
  1146.           placement operator new cannot be preempted. This allows us
  1147.           to provide an inline version of placement operator new in
  1148.           new.h:
  1149.  
  1150.              inline void *operator new(size_t, void* p) { return p; }
  1151.  
  1152.           One consequence of this is that if you explicitly define
  1153.           your own version of placement operator new (whether inline
  1154.           or out-of-line) you will get an error.  In previous
  1155.           releases, it was possible to define your own version of
  1156.           placement operator new.
  1157.  
  1158.           For example:
  1159.  
  1160.           #include <new.h>
  1161.           inline void *operator new(size_t, void* p) { return p; }
  1162.  
  1163.           will get the following error:
  1164.  
  1165.           "foo.c", line 2: error(1220): function "operator new(size_t, void *)" has
  1166.                     already been defined
  1167.             inline void *operator new(size_t, void* p) { return p; }
  1168.  
  1169.           Note that this does not prevent you from defining your own
  1170.           versions of placement operator new which have parameter
  1171.           profiles which are different from the standard All of the
  1172.           above discussion also applies to operator new [].
  1173.  
  1174.  
  1175.  
  1176.  
  1177.  
  1178.  
  1179.  
  1180.  
  1181.  
  1182.  
  1183.  
  1184.  
  1185.  
  1186.  
  1187.  
  1188.  
  1189.  
  1190.  
  1191.                                      - 19 -
  1192.  
  1193.  
  1194.  
  1195.           1.11  _L_a_n_g_u_a_g_e__S_u_p_p_o_r_t_e_d
  1196.  
  1197.           1.11.1  _N_e_w__L_a_n_g_u_a_g_e__F_e_a_t_u_r_e_s__A_c_c_e_p_t_e_d
  1198.  
  1199.           The following features not in the C++ Annotated Reference
  1200.           Manual but in the current X3716/WG21 Working Paper are
  1201.           accepted (for the 64-bit and n32 compilers only):
  1202.  
  1203.              +o The dependent statement of an "if", "while", "do", or
  1204.                "for" statement is considered to be a scope, and the
  1205.                restriction on having such a dependent statement be a
  1206.                declaration is removed.
  1207.  
  1208.              +o The draft C++ standard specifies that the scope of a
  1209.                variable declared in the for-init-statement of a for-
  1210.                loop is the scope of the loop, not the surrounding
  1211.                scope.  This feature is now implemented, but because
  1212.                this is the first compiler release to implement it, and
  1213.                because the change could break a lot of existing code,
  1214.                it has been implemented only if -LANG:ansi-for-init-
  1215.                scope=on is specified on the command line.  The default
  1216.                behavior will be changed in a future release (possibly
  1217.                in the next release).  We strongly recommend that you
  1218.                start compiling with the -LANG:ansi-for-init-scope=on
  1219.                to find and correct code that does not conform to the
  1220.                draft standard.
  1221.  
  1222.              +o Qualified names are allowed in elaborated type
  1223.                specifiers.
  1224.  
  1225.              +o A global-scope qualifier is allowed in member
  1226.                references of the form x.::A::B or p->::A::B
  1227.  
  1228.              +o The precedence of the third operand of the ? operator
  1229.                is changed.
  1230.  
  1231.              +o If control reaches the end of the main routine, and
  1232.                main has an integral return type, it is treated as if a
  1233.                "return 0" statement were executed.
  1234.  
  1235.              +o Pointers to arrays with unknown bounds as parameter
  1236.                types are diagnosed as errors.
  1237.  
  1238.              +o A functional-notation cast of the form "A()" can be
  1239.                used even if A is a class without a nontrivial
  1240.                constructor.  The temporary created gets the same
  1241.                default initialization to zero as a static object of
  1242.                the class type.
  1243.  
  1244.              +o A cast can be used to select one out of a set of
  1245.                overloaded functions when taking the address of a
  1246.  
  1247.  
  1248.  
  1249.  
  1250.  
  1251.  
  1252.  
  1253.  
  1254.  
  1255.  
  1256.  
  1257.                                      - 20 -
  1258.  
  1259.  
  1260.  
  1261.                function.
  1262.  
  1263.              +o Template friend declarations and definitions are
  1264.                permitted in class definitions and class template
  1265.                definitions.
  1266.  
  1267.              +o Type template parameters are permitted to have default
  1268.                arguments.
  1269.  
  1270.              +o Function templates may have nontype template
  1271.                parameters.
  1272.  
  1273.              +o A reference to const volatile cannot be bound to an
  1274.                rvalue.
  1275.  
  1276.              +o Qualification conversions such as conversion from (T**)
  1277.                to T const * const * are allowed.
  1278.  
  1279.              +o Static data member declarations can be used to declare
  1280.                member constants.
  1281.  
  1282.              +o wchar_t is recognized as a keyword and a distinct type.
  1283.  
  1284.              +o bool is recognized.
  1285.  
  1286.              +o RTTI (runtime type-identification), including
  1287.                dynamic_cast and the typeid operator, is implemented.
  1288.  
  1289.              +o Array new and delete are implemented.
  1290.  
  1291.              +o New-style casts (static_cast, reinterpret_cast, and
  1292.                const-cast) are implemented.
  1293.  
  1294.              +o Definition of a nested class outside its enclosing
  1295.                class is allowed.
  1296.  
  1297.              +o "mutable" is accepted on nonstatic data member
  1298.                declarations.
  1299.  
  1300.              +o Namespaces are implemented, including "using"
  1301.                declarations and directives.  Access declarations are
  1302.                broadened to match the corrsponding "using"
  1303.                declarations.
  1304.  
  1305.              +o Explicit instantiation of templates is implemented.
  1306.  
  1307.              +o The "typename" keyword is recognized.
  1308.  
  1309.              +o "explicit" is accepted to declare nonconverting
  1310.                constructors.
  1311.  
  1312.  
  1313.  
  1314.  
  1315.  
  1316.  
  1317.  
  1318.  
  1319.  
  1320.  
  1321.  
  1322.  
  1323.                                      - 21 -
  1324.  
  1325.  
  1326.  
  1327.              +o Member templates are supported.
  1328.  
  1329.              +o The new specialization syntax (using "template<>") is
  1330.                implemented.
  1331.  
  1332.              +o Cv-qualifiers are retained on rvalues (in particular,
  1333.                on function return values).
  1334.  
  1335.              +o The distinction between trivial and nontrivial
  1336.                constructors has been implemented, as has the
  1337.                distinction between PODs and non-PODs with trivial
  1338.                constructors.
  1339.  
  1340.              +o The linkage specification is treated as part of the
  1341.                function type (affecting function overloading and
  1342.                implicit conversions).
  1343.  
  1344.              +o A typedef name may be used in an explicit destructor
  1345.                call.
  1346.  
  1347.              +o Placement delete is implemented.
  1348.  
  1349.              +o enum types are considered to be non-integral types.
  1350.  
  1351.              +o Partial specialization of class templates is
  1352.                implemented.
  1353.  
  1354.           1.11.2  _N_e_w__L_a_n_g_u_a_g_e__F_e_a_t_u_r_e_s__N_o_t__A_c_c_e_p_t_e_d
  1355.  
  1356.           The following features not in the ARM but in the X3J16/WG21
  1357.           Working Paper are not accepted:
  1358.  
  1359.              +o It is not possible to overload operators using
  1360.                functions that take enum types and no class types.
  1361.  
  1362.              +o The new lookup rules for member references of the form
  1363.                x.A and p->A::B are not yet implemented.
  1364.  
  1365.              +o enum types cannot contain values larger than can be
  1366.                contained in an int.
  1367.  
  1368.              +o reinterpret_cast does not allow casting a pointer to
  1369.                member of one class to a pointer to member of another
  1370.                class.
  1371.  
  1372.              +o Explicit qualification of template functions is not
  1373.                implemented.
  1374.  
  1375.              +o The new template compilation model is not yet
  1376.                implemented.
  1377.  
  1378.  
  1379.  
  1380.  
  1381.  
  1382.  
  1383.  
  1384.  
  1385.  
  1386.  
  1387.  
  1388.  
  1389.                                      - 22 -
  1390.  
  1391.  
  1392.  
  1393.              +o In a reference of the form f()->g(), with g a static
  1394.                member function, f() is not evaluated.
  1395.  
  1396.              +o Class name injection is not implemented.
  1397.  
  1398.              +o Putting a try/catch around the initializers and body of
  1399.                a constructor is not implemented.
  1400.  
  1401.              +o The notation ::template (and ->template, etc.) is not
  1402.                implemented.
  1403.  
  1404.              +o Template template parameters are not implemented.
  1405.  
  1406.              +o Certain restrictions are not yet enforced on the use of
  1407.                pointer-to-function types that involve exception
  1408.                specifications.
  1409.  
  1410.              +o "Koenig lookup" of function names on calls is not
  1411.                implemented.
  1412.  
  1413.              +o Finding friend functions of the argument types on name
  1414.                lookup on the function name in calls is not
  1415.                implemented.
  1416.  
  1417.              +o Digraphs and operator keywords are not recognized.
  1418.  
  1419.              +o Covariant return types are not supported.
  1420.  
  1421.              +o "extern inline" is not implemented.
  1422.  
  1423.           1.11.3  _F_e_a_t_u_r_e__M_a_c_r_o_s
  1424.  
  1425.           A number of language features can be disabled via
  1426.           commandline options.  When this happens certain macros which
  1427.           are normally defined remain undefined.  These can then be
  1428.           used in #ifdefs in source files to do conditional
  1429.           compilation based on whether or not these features are
  1430.           enabled.  The following feature macros are defined or not
  1431.           depending on whether or not the corresponding feature is
  1432.           enabled.
  1433.  
  1434.              +o __EXCEPTIONS is defined unless -LANG:exceptions=off is
  1435.                specified.
  1436.  
  1437.              +o _BOOL is defined unless -LANG:bool=off is specified.
  1438.  
  1439.              +o _WCHAR_T_IS_KEYWORD is defined unless -LANG:wchar_t=off
  1440.                is specified.
  1441.  
  1442.              +o _MUTABLE_IS_KEYWORD is defined unless -LANG:mutable=off
  1443.                is specified.
  1444.  
  1445.  
  1446.  
  1447.  
  1448.  
  1449.  
  1450.  
  1451.  
  1452.  
  1453.  
  1454.  
  1455.                                      - 23 -
  1456.  
  1457.  
  1458.  
  1459.              +o _EXPLICIT_IS_KEYWORD is defined unless
  1460.                -LANG:explicit=off is specified.
  1461.  
  1462.  
  1463.           1.12  _C_+_+__C_o_m_p_i_l_e_r__F_i_l_e_s
  1464.  
  1465.           After installing the C++ Compiler images from both the
  1466.           MIPSpro C++ CD and the IRIX Development Foundation CD, you
  1467.           should have the following files:
  1468.  
  1469.           /_u_s_r/_b_i_n/_C_C                      C++ compiler driver
  1470.  
  1471.           /_u_s_r/_l_i_b_3_2/_c_m_p_l_r_s/_f_e_c_c           The n32/64-bit compiler
  1472.                                            frontend
  1473.  
  1474.           /_u_s_r/_l_i_b_3_2/_c_m_p_l_r_s/_b_e             The n32/64-bit compiler
  1475.                                            backend
  1476.  
  1477.           /_u_s_r/_l_i_b/_D_C_C/_e_d_g_c_p_f_e             The 32-bit compiler
  1478.                                            frontend
  1479.  
  1480.           /_u_s_r/_l_i_b/_D_C_C/_e_d_g__p_r_e_l_i_n_k         The "prelinker" which
  1481.                                            controls template
  1482.                                            instantiation
  1483.  
  1484.           /_u_s_r/_l_i_b/_c++/_c++_p_a_t_c_h            C++ post-processor
  1485.  
  1486.           /_u_s_r/_i_n_c_l_u_d_e/_C_C                  C++ include file directory
  1487.  
  1488.           /_u_s_r/_i_n_c_l_u_d_e/_C_C/_e_x_c_e_p_t_i_o_n._h      Entities such as
  1489.                                            _b_a_d__e_x_c_e_p_t_i_o_n,
  1490.                                            _s_e_t__t_e_r_m_i_n_a_t_e, and
  1491.                                            _s_e_t__u_n_e_x_p_e_c_t_e_d required for
  1492.                                            exception handling.
  1493.  
  1494.           /_u_s_r/_i_n_c_l_u_d_e/_C_C/_s_t_d_e_x_c_e_p_t._h      Definition of the
  1495.                                            _s_t_d::_e_x_c_e_p_t_i_o_n class, which
  1496.                                            is the base class for any
  1497.                                            exceptions thrown by the
  1498.                                            C++ runtime
  1499.  
  1500.           /_u_s_r/_l_i_b/_l_i_b_c_o_m_p_l_e_x._a            Non-template C++ complex
  1501.                                            math library for 32-bit
  1502.                                            compiler
  1503.  
  1504.           /_u_s_r/_l_i_b_3_2/_l_i_b_C_o_m_p_l_e_x._a          Template-based C++ complex
  1505.                                            math library for n32
  1506.                                            compiler
  1507.  
  1508.           /_u_s_r/_l_i_b_3_2/_l_i_b_c_o_m_p_l_e_x._a          Non-template C++ complex
  1509.                                            math library for n32
  1510.  
  1511.  
  1512.  
  1513.  
  1514.  
  1515.  
  1516.  
  1517.  
  1518.  
  1519.  
  1520.  
  1521.                                      - 24 -
  1522.  
  1523.  
  1524.  
  1525.                                            compiler
  1526.  
  1527.           /_u_s_r/_l_i_b_6_4/_l_i_b_C_o_m_p_l_e_x._a          Template-based C++ complex
  1528.                                            math library for 64-bit
  1529.                                            compiler
  1530.  
  1531.           /_u_s_r/_l_i_b_6_4/_l_i_b_c_o_m_p_l_e_x._a          Non-template C++ complex
  1532.                                            math library for 64-bit
  1533.                                            compiler
  1534.  
  1535.           /_u_s_r/_l_i_b/_c++/_l_i_b_m_a_n_g_l_e._a         C++ name-demangler library
  1536.  
  1537.           /_u_s_r/_l_i_b/_c++/_c++_f_i_l_t             C++ name-demangling utility
  1538.  
  1539.           /_u_s_r/_c_a_t_m_a_n/_u__m_a_n/_c_a_t_1/_C_C._z      C++ compiler driver manual
  1540.                                            page
  1541.  
  1542.           /_u_s_r/_r_e_l_n_o_t_e_s/_C_C                 C++ Release Notes directory
  1543.  
  1544.           The following files are present only for supporting the old
  1545.           _c_f_r_o_n_t-based compiler, and will be unavailable in future
  1546.           releases:
  1547.  
  1548.           /_u_s_r/_l_i_b/_c++/_c_f_r_o_n_t              The old C++ Translator, for
  1549.                                            use with -use_cfront
  1550.  
  1551.           /_u_s_r/_l_i_b/_c++/_m_a_r_k_c++             The old utility to identify
  1552.                                            C++ files for _d_b_x(_1)
  1553.  
  1554.           /_u_s_r/_l_i_b/_c++/_p_t_c_o_m_p              Old tool for Template
  1555.                                            support for cfront
  1556.  
  1557.           /_u_s_r/_l_i_b/_c++/_p_t_l_i_n_k              Old tool for Template
  1558.                                            support for cfront
  1559.  
  1560.           "Note:"  The C++ libraries for the 32-bit compiler
  1561.           /_u_s_r/_l_i_b/_l_i_b_C._s_o and /_u_s_r/_l_i_b/_l_i_b_C_s_u_p._s_o are  installed from
  1562.           the subsystem _c++__e_o_e._s_w._l_i_b.  This allows application
  1563.           libraries written in C++ to be used on systems that do not
  1564.           have C++ installed.  The corresponding libraries for the
  1565.           64-bit and n32 compilers are in the directories /_u_s_r/_l_i_b_6_4
  1566.           and /_u_s_r/_l_i_b_3_2 respectively and are installed from the
  1567.           subsystems _c++__e_o_e_6_4._s_w._l_i_b and  _c++__e_o_e_3_2._s_w._l_i_b
  1568.           respectively.
  1569.  
  1570.  
  1571.  
  1572.  
  1573.  
  1574.  
  1575.  
  1576.  
  1577.  
  1578.  
  1579.  
  1580.  
  1581.  
  1582.  
  1583.  
  1584.  
  1585.  
  1586.  
  1587.                                      - 25 -
  1588.  
  1589.  
  1590.  
  1591.           1.13  _C_+_+__C_o_m_p_i_l_e_r__D_o_c_u_m_e_n_t_a_t_i_o_n
  1592.  
  1593.           Silicon Graphics has produced the following C++ Compiler
  1594.           documentation:
  1595.  
  1596.              +o _C_C(1) man page (printed and online version)
  1597.  
  1598.              +o _7._2  _C++ _R_e_l_e_a_s_e _N_o_t_e_s (this online document)
  1599.  
  1600.              +o Online manual (see the packing manifest above)
  1601.  
  1602.  
  1603.           1.14  _R_u_n_t_i_m_e__P_e_r_f_o_r_m_a_n_c_e__E_n_h_a_n_c_e_m_e_n_t_s
  1604.  
  1605.  
  1606.           The 7.2   C++ compiler operating in the n32 and 64-bit mode
  1607.           provides improved runtime performance. In particular,
  1608.           performance improvements from 10% to 50% over 7.1 are
  1609.           achieved by  enhancements in inlining,  alias analysis,
  1610.           scalar and struct optimizations, and loop optimizations.
  1611.  
  1612.           The MIPSpro Compiling And Performance Tuning Guide provides
  1613.           tips on how to get the best runtime performance from C and
  1614.           C++ programs.  Additionally the following option is provided
  1615.           for improved analysis of functions which take parameters by
  1616.           const reference.
  1617.  
  1618.  
  1619.           1.14.1  _c_o_n_s_t _r_e_f_e_r_e_n_c_e _p_a_r_a_m_e_t_e_r _o_p_t_i_m_i_z_a_t_i_o_n _w_i_t_h
  1620.                   -_L_A_N_G:_a_l_i_a_s__c_o_n_s_t
  1621.  
  1622.  
  1623.           Consider the following example:
  1624.  
  1625.  
  1626.           extern void pass_by_const_ref(const int& i);
  1627.  
  1628.           int test(){
  1629.              //This requires -LANG:alias_const to get the performance enhancements
  1630.              int i = 10
  1631.              int j = 15
  1632.              pass_by_const_ref(i);
  1633.              pass_by_const_ref(j);
  1634.              return i + j;
  1635.           }
  1636.  
  1637.  
  1638.  
  1639.           In the example above, the compiler determines that the
  1640.           function pass_by_const_ref does NOT modify its formal
  1641.           parameter i: ie the parameter i passed by const reference
  1642.  
  1643.  
  1644.  
  1645.  
  1646.  
  1647.  
  1648.  
  1649.  
  1650.  
  1651.  
  1652.  
  1653.                                      - 26 -
  1654.  
  1655.  
  1656.  
  1657.           does NOT get modified in the function. Consequently the
  1658.           compiler can forward propagate the values of i and j to the
  1659.           return statement, whereas it would otherwise have had to
  1660.           reload the values of i and j after the two calls to
  1661.           pass_by_const_ref.
  1662.  
  1663.  
  1664.           (_N_O_T_E: FFFFoooorrrr tttthhhhiiiissss ooooppppttttiiiimmmmiiiizzzzaaaattttiiiioooonnnn ttttoooo wwwwoooorrrrkkkk ccccoooorrrrrrrreeeeccccttttllllyyyy,,,, bbbbooootttthhhh tttthhhheeee
  1665.           ccccaaaalllllllleeeerrrr aaaannnndddd tttthhhheeee ccccaaaalllllllleeeeeeee hhhhaaaavvvveeee ttttoooo bbbbeeee ccccoooommmmppppiiiilllleeeedddd wwwwiiiitttthhhh
  1666.           ----LLLLAAAANNNNGGGG::::aaaalllliiiiaaaassss____ccccoooonnnnsssstttt....).
  1667.  
  1668.  
  1669.           The reason this option is not on by default is that the user
  1670.           can legally cast away the const qualifier and modify the
  1671.           const parameter.
  1672.            With this option the compiler makes an effort to issue
  1673.           warnings when the callee casts away the const and modifies
  1674.           the parameter. For example,
  1675.  
  1676.  
  1677.           void f(const int &x) {int *y = (int *) &x; *y = 99;}
  1678.  
  1679.           int main() {
  1680.             int z;
  1681.             f(z); // call to f does modify z; Hence z needs to be reloaded after the call
  1682.             return z;
  1683.           }
  1684.  
  1685.  
  1686.           With the above example, and -LANG:alias_const, the compiler
  1687.           gives a warning:
  1688.  
  1689.           Compiling f__GRCi
  1690.           "ex9.C", line 2 (col. 28): warning(3334): cast to type "int *" may not be safe
  1691.                     in presence of -LANG:alias_const. Make sure you are not casting away
  1692.                     const to MODIFY the parameter
  1693.  
  1694.  
  1695.           For the above example, it is NOT safe to use
  1696.           -LANG:alias_const.  However, if the user specifies the
  1697.           "mutable" keyword then this const optimization is disabled.
  1698.           For example:
  1699.  
  1700.  
  1701.  
  1702.  
  1703.  
  1704.  
  1705.  
  1706.  
  1707.  
  1708.  
  1709.  
  1710.  
  1711.  
  1712.  
  1713.  
  1714.  
  1715.  
  1716.  
  1717.  
  1718.  
  1719.                                      - 27 -
  1720.  
  1721.  
  1722.  
  1723.  
  1724.           class C {
  1725.           public:
  1726.             mutable int p;
  1727.             void f() const { p = 99;} //mutable data member can be modified
  1728.                                       // by a const function
  1729.             int getf() const { return p;}
  1730.           };
  1731.  
  1732.           int main() {
  1733.             C c;
  1734.             c.f();// even with -LANG:alias_const, f() can modify c.p
  1735.             return c.getf();
  1736.           };
  1737.  
  1738.           The above example illustrates that in general,
  1739.           alias options should only be used with programs
  1740.           for which they are safe. For instance, -OPT:alias=unnamed
  1741.           and -OPT:alias=restrict are optimizations which are only safe for
  1742.           programs which satisfy the aliasing assumptions made by these
  1743.           optimizations. Hence such options are NOT default for C++ and
  1744.           should be used with caution.
  1745.  
  1746.  
  1747.  
  1748.  
  1749.           1.14.2  _C_o_m_p_i_l_i_n_g__w_i_t_h__-_L_A_N_G_:_e_x_c_e_p_t_i_o_n_s_=_o_f_f__f_o_r__N_O_N_-_E_H__c_o_d_e
  1750.  
  1751.  
  1752.           For code that doesn't throw/catch/propogate exceptions it is
  1753.           beneficial to compile with -LANG:exceptions=off. This
  1754.           permits optimizations that would otherwise be conservative
  1755.           around regions of code that may throw exceptions.
  1756.  
  1757.  
  1758.           1.15  _S_t_a_n_d_a_r_d__T_e_m_p_l_a_t_e__L_i_b_r_a_r_y
  1759.  
  1760.  
  1761.  
  1762.           This release includes the Standard Template Library (STL), a
  1763.           generic container, algorithm, and iterator library.  At
  1764.           present all STL code is in the form of header files, which
  1765.           are located in the directory /_u_s_r/_i_n_c_l_u_d_e/_C_C.  This
  1766.           directory is in the standard include path.
  1767.  
  1768.           This implementation of the STL is backward compatible with
  1769.           the free HP implementation, except that the definitions of
  1770.           stack, queue, and priority_queue have been changed to
  1771.           reflect the interface described by the draft C++ standard.
  1772.           New features, not part of the free HP implementation,
  1773.           include hash tables (defined in _h_a_s_h__s_e_t._h and _h_a_s_h__m_a_p._h),
  1774.  
  1775.  
  1776.  
  1777.  
  1778.  
  1779.  
  1780.  
  1781.  
  1782.  
  1783.  
  1784.  
  1785.                                      - 28 -
  1786.  
  1787.  
  1788.  
  1789.           singly linked lists (defined in _s_l_i_s_t._h), a scalable string
  1790.           representation (defined in _r_o_p_e._h) and high performance
  1791.           allocators (defined in _a_l_l_o_c._h).  This implementation of the
  1792.           STL is exception-safe and thread-safe.
  1793.  
  1794.           Features present in this release, but that were not present
  1795.           in 7.1, include:
  1796.  
  1797.              +o Exception safety. All STL components are now exception
  1798.                safe.
  1799.  
  1800.              +o New container class: _r_o_p_e. A scalable string
  1801.                representation.
  1802.  
  1803.              +o New container class: _s_l_i_s_t. Singly linked lists.
  1804.  
  1805.              +o Member templates. You can now use the fully general
  1806.                form of containers' copy constructors and insert member
  1807.                functions.  Note that this is only supported in the
  1808.                n32/64 compiler.
  1809.  
  1810.              +o New standard-conforming mechanism for accessing
  1811.                iterators' associated type information:
  1812.                _i_t_e_r_a_t_o_r__t_r_a_i_t_s.  The algorithms _c_o_u_n_t, _c_o_u_n_t__i_f, and
  1813.                _d_i_s_t_a_n_c_e have been rewritten in terms of
  1814.                _i_t_e_r_a_t_o_r__t_r_a_i_t_s.  Note that this is only supported in
  1815.                the n32/64 compiler.
  1816.  
  1817.              +o New algorithms:  _c_o_p_y__n, _l_e_x_i_c_o_g_r_a_p_h_i_c_a_l__c_o_m_p_a_r_e__3_w_a_y,
  1818.                _p_o_w_e_r, _r_a_n_d_o_m__s_a_m_p_l_e, _r_a_n_d_o_m__s_a_m_p_l_e__n,
  1819.                _u_n_i_n_i_t_i_a_l_i_z_e_d__c_o_p_y__n.
  1820.  
  1821.           Allocators in this implementation differ in function and
  1822.           interface from  allocators in the original STL documents.
  1823.           The default allocator, which is called _a_l_l_o_c, is thread-
  1824.           safe.  All containers are parameterized by allocators, so,
  1825.           for example, _l_i_s_t<_i_n_t> is equivalent to _l_i_s_t<_i_n_t, _a_l_l_o_c>.
  1826.           Three other allocators are provided:
  1827.  
  1828.              +o _s_i_n_g_l_e__c_l_i_e_n_t__a_l_l_o_c is faster but not thread-safe.
  1829.  
  1830.              +o _p_t_h_r_e_a_d__a_l_l_o_c is intended for pthreads only. It has
  1831.                better performance for multithreaded code. Objects
  1832.                should be deallocated by the allocating thread.  It is
  1833.                defined in _p_t_h_r_e_a_d__a_l_l_o_c._h.
  1834.  
  1835.              +o _m_a_l_l_o_c__a_l_l_o_c, which is preferable for use with Purify
  1836.                or other memory debugging tools.
  1837.  
  1838.              +o _d_e_b_u_g__a_l_l_o_c, an instrumenting allocator adaptor. It
  1839.                checks for improper deallocation calls in STL-
  1840.  
  1841.  
  1842.  
  1843.  
  1844.  
  1845.  
  1846.  
  1847.  
  1848.  
  1849.  
  1850.  
  1851.                                      - 29 -
  1852.  
  1853.  
  1854.  
  1855.                conformant containers.
  1856.  
  1857.           Ropes (_r_o_p_e._h in /_u_s_r/_i_n_c_l_u_d_e/_C_C) provide a scalable string
  1858.           implementation.  They are ideally suited to applications
  1859.           which must handle arbitrarily long strings with consistent
  1860.           performance, but for which in-place single-character updates
  1861.           are rare.  The time required to concatenate two ropes is
  1862.           almost independent of their length.  The interface is
  1863.           similar to, but not identical to that of basic_string
  1864.           defined in the current C++ draft standard.  The STL
  1865.           Programmer's Guide contains a more detailed description of
  1866.           both the rope interface, and the issues surrounding string
  1867.           representations in C++.
  1868.  
  1869.           The file _m_s_t_r_i_n_g._h, located in /_u_s_r/_i_n_c_l_u_d_e/_C_C, is not part
  1870.           of the STL.  It is a public domain string class written by
  1871.           Modena, and it is included for the sake of convenience. It
  1872.           is not recommended for multithreaded use.
  1873.  
  1874.  
  1875.  
  1876.           1.16  _N_e_w__t_e_m_p_l_a_t_e_-_b_a_s_e_d__c_o_m_p_l_e_x__n_u_m_b_e_r__l_i_b_r_a_r_y
  1877.  
  1878.           This release includes the template class _c_o_m_p_l_e_x, as
  1879.           described in in the draft C++ standard.  Single-precision
  1880.           complex numbers are _c_o_m_p_l_e_x<_f_l_o_a_t>, double-precision are
  1881.           _c_o_m_p_l_e_x<_d_o_u_b_l_e>, and quad precision are _c_o_m_p_l_e_x<_l_o_n_g
  1882.           _d_o_u_b_l_e>.  The template _c_o_m_p_l_e_x is declared in the header
  1883.           file _c_o_m_p_l_e_x._h.
  1884.  
  1885.           Note that this is a change from previous compiler releases:
  1886.           previous releases instead included a complex number class
  1887.           that was not a template, and that only supported double-
  1888.           precision
  1889.            complex numbers.
  1890.  
  1891.           If you are migrating code from an earlier compiler release,
  1892.           then you can either modify your code (by changing all
  1893.           instances of _c_o_m_p_l_e_x to _c_o_m_p_l_e_x<_d_o_u_b_l_e>) or else you can
  1894.           continue to use the non-template class.  You can select the
  1895.           non-template complex class by defining the macro
  1896.           __N_O_N__T_E_M_P_L_A_T_E__C_O_M_P_L_E_X before including the header _c_o_m_p_l_e_x._h.
  1897.  
  1898.           The template-based complex class is only supported on the
  1899.           n32/64 compilers.  If you are using the ucode (o32)
  1900.           compiler, then __N_O_N__T_E_M_P_L_A_T_E__C_O_M_P_L_E_X will be defined
  1901.           automatically.
  1902.  
  1903.           Regardless of whether you are using the newer template-based
  1904.           complex class or the older non-template class, the complex
  1905.           library is not automatically loaded by the C++ compiler.
  1906.  
  1907.  
  1908.  
  1909.  
  1910.  
  1911.  
  1912.  
  1913.  
  1914.  
  1915.  
  1916.  
  1917.                                      - 30 -
  1918.  
  1919.  
  1920.  
  1921.           You must explicitly provide a command-line option telling
  1922.           the compiler to link the complex library.  (This is expected
  1923.           to change in a future release.)  You must also include the
  1924.           math library, -_l_m.
  1925.  
  1926.           To use the newer, template-based complex library, include
  1927.           the options
  1928.  
  1929.               -lComplex -lm
  1930.  
  1931.           To use the older, non-template complex library, include the
  1932.           options
  1933.  
  1934.               -lcomplex -lm
  1935.  
  1936.  
  1937.  
  1938.           1.17  _R_o_g_u_e__W_a_v_e__T_o_o_l_s_._h_+_+
  1939.  
  1940.           Tools.h++ 7.03 is bundled with this release. The previous
  1941.           version of Tools.h++ is no longer supported.
  1942.  
  1943.  
  1944.           1.18  _K_n_o_w_n__P_r_o_b_l_e_m_s__a_n_d__W_o_r_k_a_r_o_u_n_d_s
  1945.  
  1946.           This section describes the known problems with the current
  1947.           release of the C++ product and how to work around them.
  1948.           Some of the descriptions are followed by a Silicon Graphics,
  1949.           Inc., bug report number in the form
  1950.           (Bug #xxxxx). Unless stated otherwise, the bugs described
  1951.           below affect the 64-bit and n32 compilation modes.
  1952.  
  1953.            +o The standard library as described in the draft standard
  1954.              is not yet completely implemented.
  1955.  
  1956.            +o The standard header files without a .h suffix are not yet
  1957.              available.
  1958.  
  1959.            +o The names in the standard library are not yet in
  1960.              namespace std.
  1961.  
  1962.            +o CC does not inline sqrt by default (Bug #439787).
  1963.  
  1964.              Unlike cc, the n32 and 64-bit C++ compiler does not by
  1965.              default use built-in operations to compute square roots,
  1966.              nor does it treat functions from the standard math
  1967.              library as having no side effects. The problem is that a
  1968.              strict application of the standard requires that many of
  1969.              these functions in fact have side effects under error
  1970.              conditions, such as a negative argument passed to the
  1971.              sqrt function.
  1972.  
  1973.  
  1974.  
  1975.  
  1976.  
  1977.  
  1978.  
  1979.  
  1980.  
  1981.  
  1982.  
  1983.                                      - 31 -
  1984.  
  1985.  
  1986.  
  1987.              To force use of the square root operations for evaluating
  1988.              the functions sqrt and sqrtf, use the commandline option
  1989.              -D__INLINE_INTRINSICS.  To improve performance of code
  1990.              using other functions in the standard math library use
  1991.              the option -D__MATH_HAS_NO_SIDE_EFFECTS.
  1992.  
  1993.  
  1994.            +o Exception runtime failures (Bug #405567).
  1995.  
  1996.              Runtime assertion errors will result if an exception is
  1997.              thrown as a result of reaching the per process file
  1998.              descriptor limit or if there is no more memory available.
  1999.              The default operator new does not throw an exception when
  2000.              allocation of requested storage fails.
  2001.  
  2002.            +o Making a static/extern _l_o_c_a_l in a mp region is not
  2003.              implemented (Bug #437716).
  2004.  
  2005.              Consider the following example:  The variable _i declared
  2006.              as a _s_t_a_t_i_c _i_n_t is being made local in the parallel
  2007.              region.  The semantics of _l_o_c_a_l dictate that a local copy
  2008.              is made within each process and the local copy is
  2009.              initialized to -3.
  2010.  
  2011.              However, the call to _f() within the parallel region also
  2012.              refers to _i which should still get the value assigned to
  2013.              the _s_t_a_t_i_c _i_n_t ( i.e. 44).  This is indeed the observed
  2014.              behavior when _f() is not inlined. However, if _f() is
  2015.              inlined, the _i that it refers to gets a value of -3.
  2016.  
  2017.              To workaround this problem remove the local _i and replace
  2018.              it by _i_n_t _i in the parallel region.  This has the same
  2019.              effect as declaring _i as a local, since by default,
  2020.              variables declared within an MP region are local.
  2021.  
  2022.              The code below illustrates this:
  2023.  
  2024.  
  2025.  
  2026.  
  2027.  
  2028.  
  2029.  
  2030.  
  2031.  
  2032.  
  2033.  
  2034.  
  2035.  
  2036.  
  2037.  
  2038.  
  2039.  
  2040.  
  2041.  
  2042.  
  2043.  
  2044.  
  2045.  
  2046.  
  2047.  
  2048.  
  2049.                                      - 32 -
  2050.  
  2051.  
  2052.  
  2053.              #include <stdio.h>
  2054.              static int i;
  2055.              __inline int  f () { return i < 0;}
  2056.  
  2057.              void main() {
  2058.              i = 44;
  2059.              /* workaround: remove the "local i" replace by "int i" in the parallel region
  2060.              // This has the same effect as declaring i as a local since by default
  2061.              // variables declared within an MP region are local
  2062.              */
  2063.              #pragma parallel local (i)
  2064.              {
  2065.                 i = -3;
  2066.                 if (f())
  2067.                    printf("Incorrect ANSWER wrt mp ");
  2068.                 else
  2069.                    printf("Correct Answer wrt mp");
  2070.  
  2071.              }
  2072.  
  2073.            +o Under certain very rare circumstances, a compiler
  2074.              internal error results in the message "A goto outside a
  2075.              region cannot jump to a label inside a region."  This
  2076.              error occurs only when exceptions are enabled, and is
  2077.              known to occur only when a natural if-then-else is
  2078.              written with if's and goto's:  e.g.
  2079.  
  2080.                 if (n == 0) goto label1;
  2081.                 goto label2;
  2082.              label1:
  2083.                 ...
  2084.              label2:
  2085.                 ...
  2086.  
  2087.              If the source cannot be rewritten, then the program
  2088.              should be compiled with -LANG:exceptions=off.
  2089.  
  2090.            +o The use of -anach with -n32 is deprecated (Bug #514250)
  2091.  
  2092.              The following example (see the function proc_bad)
  2093.              illustrates a style of function definition (similar to
  2094.              the K&R mode in C) which was supported with the -anach
  2095.              flag in the ucode compilers for historical reasons. The
  2096.              C++ standard requires the user to write the function in a
  2097.              style consistent with the ANSI C style (see the function
  2098.              proc_good).
  2099.  
  2100.              With CC -32 -anach the code compiles and produces correct
  2101.              results (values of 123 and 123 get printed). With CC -n32
  2102.              -anach the code does compile, however it produces
  2103.              incorrect results (a value of 123, and 0 get printed).
  2104.  
  2105.  
  2106.  
  2107.  
  2108.  
  2109.  
  2110.  
  2111.  
  2112.  
  2113.  
  2114.  
  2115.                                      - 33 -
  2116.  
  2117.  
  2118.  
  2119.                    #include <stdio.h>
  2120.  
  2121.                    class C
  2122.                    {
  2123.                    public:
  2124.                      int v;
  2125.                      C() { v = 123; };
  2126.                      C(C& ob) { v = ob.v; };
  2127.                    };
  2128.  
  2129.                    int proc_good(C c) { return c.v; }
  2130.                    int proc_bad(c) C c; { return c.v; } // rewrite as proc_good
  2131.  
  2132.                    main()
  2133.                    {
  2134.                      C c;
  2135.                      printf("%d0, proc_good(c));
  2136.                      printf("%d0, proc_bad(c));
  2137.                    }
  2138.  
  2139.              We suggest that the function proc_bad  be rewritten as
  2140.              proc_good to conform to the C++ standard. Such a source
  2141.              transformation can even be done using a script.
  2142.  
  2143.            +o Internal error with exceptions and IPA (Bug# 512292).
  2144.  
  2145.              Under rare circumstances (when exceptions are on and when
  2146.              compiling with -IPA and when certain other conditions
  2147.              apply) the compiler may generate an internal error. As a
  2148.              workaround we suggest with -IPA:clone=off, or if the code
  2149.              doesn't throw or catch or propogate exceptions, compiling
  2150.              with -LANG:exceptions=off.
  2151.  
  2152.            +o Generating assembly using -S can cause a coredump if
  2153.              extremely long names (such as those generated by C++
  2154.              template functions) are involved. (Bug #707102).
  2155.  
  2156.            +o C/C++ internal error (Bug #480882).
  2157.              The C/C++ compilers reserve the charcaters 0x81 and 0x82.
  2158.              Usage of these characters might either cause the compiler
  2159.              to core dump or emit the following error:  Internal error
  2160.              loop: nested_source_line_modif: bad address
  2161.  
  2162.  
  2163.  
  2164.  
  2165.  
  2166.  
  2167.  
  2168.  
  2169.  
  2170.  
  2171.  
  2172.  
  2173.  
  2174.  
  2175.  
  2176.  
  2177.  
  2178.